﻿#region Using

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Linq;
using System.Timers;
using System.Windows.Forms;

#endregion Using

namespace T4_Eind_programma
{
    public partial class Hoofdscherm : Form
    {
        #region Variable Declaration

        private const string bestellerInvullen = "Vul een besteller in.";
        private const string mengverhouding = "DB350_C1.mengverhouding";
        private const string noodstopOPCNaam = "Noodstop";
        private const string pauzeOPCNaam = "Pauzeren";
        private const string statusBezig = "Bezig";
        private const string statusInactief = "Inactief";
        private const string statusNoodstop = "Noodstop";
        private const string statusPauze = "Pauze";
        private Controller mijnController;
        private System.Timers.Timer updateStatusStripInfo = new System.Timers.Timer(500);
        private System.Timers.Timer updateStatusStripLocalTime = new System.Timers.Timer(1000);
        private System.Timers.Timer updateStatusStripTime = new System.Timers.Timer(1000);
        private System.Timers.Timer timerRefreshOEE = new System.Timers.Timer(5000);

        #endregion Variable Declaration

        #region Constructor

        public Hoofdscherm()
        {
            InitializeComponent();
            mijnController = new Controller(this);
            InitialiseerProgramma();
        }

        private void InitialiseerProgramma()
        {
            mijnController.OrderList.ListChanged += orderList_ListChanged;
            textToevoegen.Text = bestellerInvullen;
            updateStatusStripLocalTime.Interval = (1000 - DateTime.Now.Millisecond);
            updateStatusStripInfo.Elapsed += statusRefreshTimer_Elapsed;
            updateStatusStripTime.Elapsed += statusTimeTimer_Elapsed;
            updateStatusStripLocalTime.Elapsed += statusLocalTimeTimer_Elapsed;
            timerRefreshOEE.Elapsed += new ElapsedEventHandler(timerRefreshOEE_Elapsed);

            updateStatusStripTime.Start();
            updateStatusStripInfo.Start();
            updateStatusStripLocalTime.Start();

            updateStatusStripInfo.AutoReset = true;
            updateStatusStripTime.AutoReset = true;
            updateStatusStripLocalTime.AutoReset = true;

            RefreshListView();
            RefreshListViewHistorie();
            RefreshListViewOpgeslagenSessies();
            btnPauze.Enabled = false;
            buttonNoodstop.Enabled = false;
        }

        #endregion Constructor

        #region Main

        private static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Hoofdscherm());
        }

        #endregion Main

        #region ETC

        public void AddToLog(string text, Color kleur)
        {
            if (textBoxLog.InvokeRequired)
            {
                textBoxLog.Invoke(new MethodInvoker(() => { AddToLog(text, kleur); }));
            }

            else
            {
                textBoxLog.AppendText(DateTime.Now.ToString("HH:mm:ss") + ": ");
                textBoxLog.SelectionColor = kleur;
                textBoxLog.AppendText(text + Environment.NewLine);
                textBoxLog.SelectionStart = textBoxLog.Text.Length;
                textBoxLog.ScrollToCaret();
            }
        }

        public string VindLaatsteRegelTextBox()
        {
            string text = textBoxLog.Lines[textBoxLog.Lines.Length - 1];
            string[] splitter = text.Split(':');
            return splitter[1];
        }

        private void checkBoxUpdate_CheckedChanged(object sender, EventArgs e)
        {
            if (checkBoxUpdate.Checked == true)
                if (timerRefreshOEE.Enabled == false)
                    timerRefreshOEE.Start();
                else
                    if (timerRefreshOEE.Enabled == true)
                        timerRefreshOEE.Stop();
        }

        private void InitializeToevoegen(int nummer)
        {
            Order order = mijnController.OrderList.Where(orderItem => orderItem.Nummer == nummer).Single();
            BatchOverzicht mijnBatchScherm = new BatchOverzicht(order, this);
            mijnBatchScherm.Closing += new System.ComponentModel.CancelEventHandler(OnSearchClosing);
            this.Enabled = false;
            mijnBatchScherm.MijnOrder.MengbatchList.ListChanged += MengbatchList_ListChanged;
            mijnBatchScherm.Show();
        }

        private void listOrder_KeyDown(object sender, KeyEventArgs e)
        {
            try
            {
                int huidigIndex = 0;
                int nieuweIndex = 0;
                if (e.KeyCode == Keys.Up)
                {
                    if (listOrder.SelectedItems.Count > 0 && listOrder.SelectedItems[0].Index != listOrder.Items[0].Index)
                    {
                        huidigIndex = listOrder.SelectedItems[0].Index;
                        nieuweIndex = huidigIndex - 1;
                        Order temporder = mijnController.OrderList[huidigIndex];
                        var countBezig = (from item in temporder.MengbatchList
                                          where item.Status == "Bezig"
                                          select item);
                        if (countBezig.Count() > 0)
                        {
                            AddToLog("Deze order heeft mengbatches die in gebruik zijn, verplaatsen niet mogelijk", Color.Red);
                            return;
                        }
                        Order temporderNieuw = mijnController.OrderList[nieuweIndex];
                        mijnController.OrderList[huidigIndex] = temporderNieuw;
                        mijnController.OrderList[nieuweIndex] = temporder;
                        listOrder.Items[huidigIndex].Selected = true;
                        listOrder.Items[huidigIndex].Focused = true;
                    }
                }
                else if (e.KeyCode == Keys.Down)
                {
                    if (listOrder.SelectedItems.Count > 0 && listOrder.SelectedItems[0].Index != listOrder.Items[listOrder.Items.Count - 1].Index)
                    {
                        huidigIndex = listOrder.SelectedItems[0].Index;
                        nieuweIndex = huidigIndex + 1;
                        Order temporder = mijnController.OrderList[huidigIndex];
                        var countBezig = (from item in temporder.MengbatchList
                                          where item.Status == "Bezig"
                                          select item);
                        if (countBezig.Count() > 0)
                        {
                            AddToLog("Deze order heeft mengbatches die in gebruik zijn, verplaatsen niet mogelijk", Color.Red);
                            return;
                        }
                        Order temporderNieuw = mijnController.OrderList[nieuweIndex];
                        mijnController.OrderList[huidigIndex] = temporderNieuw;
                        mijnController.OrderList[nieuweIndex] = temporder;
                        listOrder.Items[huidigIndex].Selected = true;
                        listOrder.Items[huidigIndex].Focused = true;
                    }
                }
                else if (e.KeyCode == Keys.Delete)
                {
                    if (listOrder.SelectedItems.Count == 1)
                    {
                        BindingList<Order> tempList = new BindingList<Order>();

                        Order order = mijnController.OrderList.Where(orderItem => orderItem.Nummer == Convert.ToInt32(listOrder.SelectedItems[0].SubItems[0].Text)).Single();
                        foreach (var item in order.MengbatchList)
                        {
                            if (item.Status == statusBezig)
                            {
                                AddToLog("Gekozen order bevat batches die uitgevoerd worden, verwijderen niet mogelijk", Color.Red);
                                return;
                            }
                        }
                        var query = (from orderItem in order.MengbatchList
                                     where orderItem.Klaar == true
                                     select orderItem);
                        if (query.Count() > 0)
                        {
                            tempList = mijnController.MijnIO.ReadOrderList(mijnController.MijnIO.Location, mijnController.MijnIO.FileNameRemovedMengbatches);
                            tempList.Add(order);
                        }

                        mijnController.OrderList.Remove(order);
                        AddToLog("Order " + order.Nummer + " met " + order.MengbatchList.Count + " mengbatch(es) is verwijderd.", Color.Black);
                    }
                }
                listOrder.Focus();
                listOrder.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
            }
            catch (Exception)
            {
            }
        }

        #endregion ETC

        #region Click Events

        private void btnPauze_Click(object sender, EventArgs e)
        {
            ItemInfo info = (from iteminfo in mijnController.ItemInfoList
                             where iteminfo.FilteredName == pauzeOPCNaam
                             select iteminfo).FirstOrDefault();
            if (info != null)
            {
                var infoList = new List<ItemInfo>();
                info.ItemValue = !Convert.ToBoolean(info.ItemValue);
                infoList.Add(info);
                mijnController.GeefInfoListDoorAanOPC(infoList);
                var reden = new RedenInactiviteit("Pauze werd geactiveerd", DateTime.Now);
                if (Convert.ToBoolean(info.ItemValue) == true)
                {
                    AddToLog("Systeem is gepauzeerd.", Color.Black);
                    mijnController.TotalTimeActive.Stop();
                    mijnController.TotalTimeInactive.Start();
                    mijnController.TimerUitvoer.Stop();
                    mijnController.OeeItemList[mijnController.OeeItemList.Count - 1].RedenLijst.Add(reden);
                    var redenPauze = (from reden2 in mijnController.OeeItemList[mijnController.OeeItemList.Count - 1].RedenLijst
                                      where reden2.Reden == "Pauze werd geactiveerd"
                                      select reden2).LastOrDefault();

                    if (redenPauze != null) redenPauze.TijdInactief.Start();

                    foreach (var item in mijnController.OrderList)
                    {
                        foreach (var meng in item.MengbatchList)
                        {
                            if (meng.Status == statusBezig) meng.Status = statusPauze;
                        }
                    }
                }
                else
                {
                    AddToLog("Systeem is hervat.", Color.Black);
                    mijnController.TotalTimeActive.Start();
                    mijnController.TotalTimeInactive.Stop();
                    mijnController.TimerUitvoer.Start();
                    var redenPauze = (from reden2 in mijnController.OeeItemList[mijnController.OeeItemList.Count - 1].RedenLijst
                                      where reden2.Reden == "Pauze werd geactiveerd"
                                      select reden2).LastOrDefault();

                    if (redenPauze != null) redenPauze.StopTimerActief();

                    foreach (var item in mijnController.OrderList)
                    {
                        foreach (var meng in item.MengbatchList)
                        {
                            if (meng.Status == statusPauze) meng.Status = statusBezig;
                        }
                    }
                }
            }
            else AddToLog("Er is geen verbinding met de OPC, pauzeren is niet mogelijk", Color.Red);
        }

        private void btnToevoegen_Click(object sender, EventArgs e)
        {
            if (textToevoegen.Text.Length > 0 && textToevoegen.Text != "Vul een besteller in.")
            {
                int nieuwnummer = 0;
                foreach (Order order in mijnController.OrderList)
                {
                    if (order.Nummer >= nieuwnummer)
                    {
                        nieuwnummer = order.Nummer + 1;
                    }
                }

                foreach (Order order in mijnController.MijnIO.ReadOrderList(mijnController.MijnIO.Location, mijnController.MijnIO.FileNameRemovedMengbatches))
                {
                    if (order.Nummer >= nieuwnummer)
                    {
                        nieuwnummer = order.Nummer + 1;
                    }
                }

                if (mijnController.OrderList.Count >= 1)
                {
                    mijnController.OrderList.Add(new Order(nieuwnummer, textToevoegen.Text, false));
                }
                else
                {
                    mijnController.OrderList.Add(new Order(nieuwnummer, textToevoegen.Text, false));
                }
                InitializeToevoegen(nieuwnummer);
            }
            else
            {
                AddToLog(bestellerInvullen, Color.Red);
            }
        }

        private void btnUitvoeren_Click(object sender, EventArgs e)
        {
            textBoxLog.Clear();

            var c1Bezig = (from infoBezig in mijnController.ItemInfoList
                           where infoBezig.FilteredName == "C1_bezig"
                           select infoBezig).FirstOrDefault();
            var noodstop = (from noodstopInfo in mijnController.ItemInfoList
                            where noodstopInfo.FilteredName == "Noodstop"
                            select noodstopInfo).FirstOrDefault();

            if (c1Bezig != null || noodstop != null)
            {
                var infoList = new List<ItemInfo>();
                if (c1Bezig != null)
                {
                    c1Bezig.ItemValue = false;

                    infoList.Add(c1Bezig);
                }
                if (noodstop != null)
                {
                    c1Bezig.ItemValue = false;

                    infoList.Add(noodstop);
                }
                mijnController.GeefInfoListDoorAanOPC(infoList);
            }
            if (listOrder.Items.Count > 0)
            {
                if (mijnController.TimerUitvoer.Enabled == false)
                {
                    mijnController.TimerUitvoer.Start();
                    mijnController.TotalTimeActive.Start();
                    mijnController.TotalTimeInactive.Stop();
                    var redenNoodstop = (from reden2 in mijnController.OeeItemList[mijnController.OeeItemList.Count - 1].RedenLijst
                                         where reden2.Reden == "Noodstop werd geactiveerd."
                                         select reden2).LastOrDefault();
                    var redenNietUitvoeren = (from reden2 in mijnController.OeeItemList[mijnController.OeeItemList.Count - 1].RedenLijst
                                              where reden2.Reden == "Nog niet op uitvoeren gedrukt"
                                              select reden2).LastOrDefault();
                    var redenNaNoodstop = (from reden2 in mijnController.OeeItemList[mijnController.OeeItemList.Count - 1].RedenLijst
                                           where reden2.Reden == "Na de noodstop nog niet op uitvoeren gedrukt."
                                           select reden2).LastOrDefault();

                    if (redenNoodstop != null) redenNoodstop.StopTimerActief();

                    if (redenNietUitvoeren != null) redenNietUitvoeren.StopTimerActief();

                    if (redenNaNoodstop != null) redenNaNoodstop.StopTimerActief();

                    AddToLog("Er wordt nu uitgevoerd.", Color.Black);
                }
                else { AddToLog("Er wordt al uitgevoerd.", Color.Red); }
            }
            else { AddToLog("Er zijn geen orders aanwezig om uit te voeren.", Color.Red); }
        }

        private void buttonNoodstop_Click(object sender, EventArgs e)
        {
            var query = (from item in mijnController.ItemInfoList
                         where item.FilteredName == noodstopOPCNaam
                         select item).FirstOrDefault();
            if (query != null)
            {
                if (mijnController.TimerUitvoer.Enabled == true || Convert.ToBoolean(query.ItemValue) == true)
                {
                    mijnController.TimerUitvoer.Stop();
                    mijnController.TotalTimeActive.Stop();
                    mijnController.TotalTimeInactive.Start();
                    var infoList = new List<ItemInfo>();
                    query.ItemValue = !Convert.ToBoolean(query.ItemValue);
                    infoList.Add(query);
                    mijnController.GeefInfoListDoorAanOPC(infoList);

                    if (Convert.ToBoolean(query.ItemValue) == true)
                    {
                        var reden = new RedenInactiviteit("Noodstop werd geactiveerd.", DateTime.Now);
                        mijnController.OeeItemList[mijnController.OeeItemList.Count - 1].RedenLijst.Add(reden);
                        AddToLog("Noodstop is geactiveerd.", Color.Black);
                        var redenNoodstop = (from reden2 in mijnController.OeeItemList[mijnController.OeeItemList.Count - 1].RedenLijst
                                             where reden2.Reden == "Noodstop werd geactiveerd."
                                             select reden2).LastOrDefault();

                        if (redenNoodstop != null) redenNoodstop.TijdInactief.Start();

                        foreach (var item in mijnController.OrderList)
                        {
                            foreach (var meng in item.MengbatchList)
                            {
                                if (meng.Status == statusBezig) meng.Status = statusNoodstop;
                            }
                        }
                    }
                    else
                    {
                        var redenNoodstop = (from reden2 in mijnController.OeeItemList[mijnController.OeeItemList.Count - 1].RedenLijst
                                             where reden2.Reden == "Noodstop werd geactiveerd."
                                             select reden2).LastOrDefault();

                        if (redenNoodstop != null) redenNoodstop.StopTimerActief();

                        var reden = new RedenInactiviteit("Na de noodstop nog niet op uitvoeren gedrukt.", DateTime.Now);
                        mijnController.OeeItemList[mijnController.OeeItemList.Count - 1].RedenLijst.Add(reden);

                        var redenNaNoodstop = (from reden2 in mijnController.OeeItemList[mijnController.OeeItemList.Count - 1].RedenLijst
                                               where reden2.Reden == "Na de noodstop nog niet op uitvoeren gedrukt."
                                               select reden2).LastOrDefault();

                        if (redenNaNoodstop != null) redenNaNoodstop.TijdInactief.Start();
                        AddToLog("Noodstop is deactiveerd.", Color.Black);
                    }
                }
                else AddToLog("Systeem is niet actief, noodstop niet mogelijk.", Color.Red);
            }
            else AddToLog("Er is geen verbinding met de OPC, noodstop is niet mogelijk", Color.Red);
        }

        private void HistorieItemDoubleClciked(object sender, System.EventArgs e)
        {
            try
            {
                Mengbatch mengbatch = mijnController.OrderList[listBatch.SelectedItems[0].Index].MengbatchList.Where
                    (mengbatchItem => mengbatchItem.Nummer == Convert.ToInt32(listBatch.SelectedItems[0].Text)).FirstOrDefault();
                VulbatchScherm mijnHistorieVulBatch = new VulbatchScherm(mengbatch);
                mijnHistorieVulBatch.Closing += new System.ComponentModel.CancelEventHandler(OnSearchClosingVulbatch);
                this.Enabled = false;

                mijnHistorieVulBatch.Show();
            }
            catch (Exception)
            {
            }
        }

        private void listBatch_DoubleClick(object sender, EventArgs e)
        {
            try
            {
                Order mijnOrder = mijnController.OrderList.Where
    (orderItem => orderItem.Nummer == Convert.ToInt32(listBatch.SelectedItems[0].SubItems[0].Text)).Single();
                Mengbatch mengbatch = mijnOrder.MengbatchList.Where
    (mengbatchItem => mengbatchItem.Nummer == Convert.ToInt32(listBatch.SelectedItems[0].SubItems[1].Text)).Single();
                VulbatchScherm mijnHistorieVulBatch = new VulbatchScherm(mengbatch);
                mijnHistorieVulBatch.Closing += new System.ComponentModel.CancelEventHandler(OnSearchClosingVulbatch);
                this.Enabled = false;
                mijnHistorieVulBatch.Show();
            }
            catch (Exception)
            {
            }
        }

        private void listOrder_DoubleClick(object sender, EventArgs e)
        {
            try
            {
                Order order = mijnController.OrderList.Where(orderItem => orderItem.Nummer == Convert.ToInt32(listOrder.SelectedItems[0].SubItems[0].Text)).Single();
                BatchOverzicht mijnBatchScherm = new BatchOverzicht(order, this);
                mijnBatchScherm.Closing += new System.ComponentModel.CancelEventHandler(OnSearchClosing);
                this.Enabled = false;
                mijnBatchScherm.WijzigenActief = true;
                mijnBatchScherm.Show();
                mijnBatchScherm.MijnOrder.MengbatchList.ListChanged += this.MengbatchList_ListChanged;
            }
            catch (Exception)
            {
            }
        }

        private void listViewSavedSessions_DoubleClick(object sender, EventArgs e)
        {
            try
            {
                OEEItem mijnOEEItem = mijnController.OeeItemList.Where(oee => oee.SessieDatum.ToString("MM/dd/yyyy:HH:mm:ss") ==
        (listViewSavedSessions.SelectedItems[0].SubItems[0].Text + ":" + listViewSavedSessions.SelectedItems[0].SubItems[1].Text)).First();

                OEEScherm mijnOEEScherm = new OEEScherm(mijnOEEItem);
                mijnOEEScherm.Closing += new System.ComponentModel.CancelEventHandler(OnSearchClosingOEE);
                this.Enabled = false;
                mijnOEEScherm.Show();
            }
            catch (Exception)
            {
            }
        }

        private void toolStripStatusLabelVerbindingText_DoubleClick(object sender, EventArgs e)
        {
            if (mijnController.CheckVerbinding() == false)
            {
                mijnController.MaakVerbinding();
                mijnController.AanmakenTags();
            }
            else
                mijnController.DisconnectOPC();
        }

        #endregion Click Events

        #region Close Events

        private void AfsluitProcedure()
        {
            mijnController.MijnIO.WriteDoeltanken(mijnController.DoelTanken);
            mijnController.OeeItemList[mijnController.OeeItemList.Count - 1].TotaleTijdVanSessie = Convert.ToDateTime(mijnController.TotalTime.Elapsed.ToString());
            mijnController.OeeItemList[mijnController.OeeItemList.Count - 1].TotaleTijdActiefVanSessie = Convert.ToDateTime(mijnController.TotalTimeActive.Elapsed.ToString());
            mijnController.OeeItemList[mijnController.OeeItemList.Count - 1].TotaleTijdInActiefVanSessie = Convert.ToDateTime(mijnController.TotalTimeInactive.Elapsed.ToString());

            foreach (var item in mijnController.OeeItemList[mijnController.OeeItemList.Count - 1].RedenLijst)
            {
                if (item.TijdInactief.IsRunning == true)
                    item.StopTimerActief();
            }

            mijnController.MijnIO.WriteOEE(mijnController.OeeItemList);
            mijnController.MijnIO.WriteOrderList(mijnController.MijnIO.Location, mijnController.MijnIO.FileNameOrder, mijnController.OrderList);
            mijnController.DisconnectOPC();
        }

        private void Hoofdscherm_FormClosing(object sender, FormClosingEventArgs e)
        {
            AfsluitProcedure();
        }

        private void OnApplicationExit(object sender, EventArgs e)
        {
            AfsluitProcedure();
        }

        private void OnSearchClosing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            this.Enabled = true;
            Order order = (from orderItem in this.mijnController.OrderList
                           where orderItem.MengbatchList.Count == 0
                           select orderItem).FirstOrDefault();
            if (order != null)
                this.mijnController.OrderList.Remove(order);
            else
            {
                mijnController.MijnIO.WriteOrderList(mijnController.MijnIO.Location, mijnController.MijnIO.FileNameOrder, mijnController.OrderList);
                BatchOverzicht senderObject = (BatchOverzicht)sender;
                if (senderObject.WijzigenActief == false)
                    AddToLog("Order " + this.mijnController.OrderList[this.mijnController.OrderList.Count - 1].Nummer + " met " + this.mijnController.OrderList[this.mijnController.OrderList.Count - 1].MengbatchList.Count + " mengbatch(es) is toegevoegt.", Color.Black);
                else
                {
                    if (senderObject.MijnOrder != senderObject.OrderCheck)
                        AddToLog("Order " + this.mijnController.OrderList[this.mijnController.OrderList.Count - 1].Nummer + " is gewijzigd.", Color.Black);
                }
            }
        }

        private void OnSearchClosingOEE(object sender, System.ComponentModel.CancelEventArgs e)
        {
            this.Enabled = true;
        }

        private void OnSearchClosingVulbatch(object sender, System.ComponentModel.CancelEventArgs e)
        {
            this.Enabled = true;
        }

        #endregion Close Events

        #region List Changed Event

        private void historieOrderList_ListChanged(object sender, ListChangedEventArgs e)
        {
            RefreshListViewHistorie();
        }

        private void MengbatchList_ListChanged(object sender, ListChangedEventArgs e)
        {
            RefreshListView();
            mijnController.MijnIO.WriteOrderList(mijnController.MijnIO.Location, mijnController.MijnIO.FileNameOrder, mijnController.OrderList);
        }

        private void orderList_ListChanged(object sender, ListChangedEventArgs e)
        {
            RefreshListView();
            RefreshListViewHistorie();
        }

        #endregion List Changed Event

        #region Textbox Toevoegen

        private void textToevoegen_Enter(object sender, EventArgs e)
        {
            textToevoegen.Text = "";
        }

        private void textToevoegen_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                if (textToevoegen.Text.Length > 0 && textToevoegen.Text != bestellerInvullen)
                {
                    int nieuwnummer = 0;
                    foreach (Order order in mijnController.OrderList)
                    {
                        if (order.Nummer >= nieuwnummer)
                        {
                            nieuwnummer = order.Nummer + 1;
                        }
                    }

                    foreach (Order order in mijnController.MijnIO.ReadOrderList(mijnController.MijnIO.Location, mijnController.MijnIO.FileNameRemovedMengbatches))
                    {
                        if (order.Nummer >= nieuwnummer)
                        {
                            nieuwnummer = order.Nummer + 1;
                        }
                    }

                    if (mijnController.OrderList.Count >= 1)
                    {
                        mijnController.OrderList.Add(new Order(nieuwnummer, textToevoegen.Text, false));
                    }
                    else
                    {
                        mijnController.OrderList.Add(new Order(nieuwnummer, textToevoegen.Text, false));
                    }
                    InitializeToevoegen(nieuwnummer);
                }
                else
                {
                    AddToLog(bestellerInvullen, Color.Red);
                }
            }
        }

        private void textToevoegen_Leave(object sender, EventArgs e)
        {
            if (textToevoegen.Text == "")
                textToevoegen.Text = bestellerInvullen;
        }

        #endregion Textbox Toevoegen

        #region RefreshListView

        public void RefreshListViewOEE()
        {
            if (listViewOEE.InvokeRequired)
            {
                listViewOEE.Invoke(new MethodInvoker(() => { RefreshListViewOEE(); }));
            }
            else
            {
                listViewOEE.Items.Clear();
                foreach (ItemInfo item in mijnController.ItemInfoList)
                {
                    if (mijnController.MijnIO.CheckInfoForWrite(item) == true)
                    {
                        ListViewItem lv = new ListViewItem(item.FilteredName);
                        try
                        {
                            if (item.ActiveTimer != null)
                            {
                                TimeSpan timeSpan = TimeSpan.FromSeconds(Convert.ToInt32((item.ActiveTimer.Elapsed.TotalSeconds)));
                                lv.SubItems.Add(timeSpan.ToString());
                            }

                            else
                            {
                                lv.SubItems.Add("00:00:00");
                            }
                        }
                        catch (Exception)
                        {
                        }
                        finally
                        {
                            try
                            {
                                if (mijnController.TotalTimeActive != null)
                                {
                                    lv.SubItems.Add(item.BerekenEffectiviteit(mijnController.TotalTimeActive.Elapsed));
                                }
                                else
                                {
                                    lv.SubItems.Add("0");
                                }
                            }
                            catch (Exception)
                            {
                            }
                            finally
                            {
                                lv.SubItems.Add(item.Active.ToString());
                                if (item.ItemValue != null) lv.SubItems.Add(item.ItemValue.ToString());
                                else lv.SubItems.Add(false.ToString());

                                listViewOEE.Items.Add(lv);
                            }
                        }
                    }
                }
                listViewOEE.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
                LoadRedenenIntoListView(mijnController.OeeItemList[mijnController.OeeItemList.Count - 1]);
            }
        }

        private void LoadRedenenIntoListView(OEEItem mijnOee)
        {
            if (listViewStilstaan.InvokeRequired)
            {
                listViewStilstaan.Invoke(new MethodInvoker(() => { LoadRedenenIntoListView(mijnOee); }));
            }

            else
            {
                try
                {
                    listViewStilstaan.Items.Clear();
                    foreach (var item in mijnOee.RedenLijst)
                    {
                        ListViewItem lv = new ListViewItem(item.BeginTijd.ToString());
                        lv.SubItems.Add(item.TijdInactief.Elapsed.ToString());
                        lv.SubItems.Add(item.Reden.ToString());
                        listViewStilstaan.Items.Add(lv);
                    }
                    listViewStilstaan.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
                }
                catch (Exception)
                {
                }
            }
        }

        private void RefreshListView()
        {
            try
            {
                listOrder.Items.Clear();

                foreach (Order order in mijnController.OrderList)
                {
                    if (order.Klaar == false)
                    {
                        ListViewItem lv = new ListViewItem(order.Nummer.ToString());
                        lv.SubItems.Add(order.Klaar.ToString());
                        lv.SubItems.Add(order.MengbatchList.Count.ToString());
                        lv.SubItems.Add(order.Naam);

                        listOrder.Items.Add(lv);
                    }
                }
                listOrder.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
            }
            catch (Exception)
            {
            }
        }

        private void RefreshListViewHistorie()
        {
            listBatch.Items.Clear();
            foreach (Order order in mijnController.OrderList)
            {
                foreach (Mengbatch batch in order.MengbatchList)
                {
                    if (batch.Klaar == true)
                    {
                        ListViewItem lv = new ListViewItem(order.Nummer.ToString());
                        lv.SubItems.Add(batch.Nummer.ToString());
                        lv.SubItems.Add(batch.Productcode.ToString());
                        lv.SubItems.Add(batch.Smaak.Naam);
                        lv.SubItems.Add(batch.Hoeveelheid.ToString());
                        lv.SubItems.Add(batch.SiroopPercentage.ToString());
                        lv.SubItems.Add(batch.Mengtijd.ToString());
                        lv.SubItems.Add(batch.Verwarmen.ToString());
                        lv.SubItems.Add(batch.Handmatig.ToString());
                        var temp = "";
                        foreach (var item in (batch.Doeltank))
                        {
                            temp += item.Naam + ",";
                        }
                        lv.SubItems.Add(temp);
                        lv.SubItems.Add(batch.Klaar.ToString());
                        listBatch.Items.Add(lv);
                    }
                }
            }
            listBatch.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
        }

        private void RefreshListViewOpgeslagenSessies()
        {
            listViewSavedSessions.Items.Clear();
            foreach (OEEItem oeeItem in mijnController.OeeItemList)
            {
                if (oeeItem.TotaleTijdVanSessie.ToString("HH:mm:ss") != "00:00:00")
                {
                    ListViewItem lv = new ListViewItem(oeeItem.SessieDatum.ToString("MM/dd/yyyy"));
                    lv.SubItems.Add(oeeItem.SessieDatum.ToString("HH:mm:ss"));
                    lv.SubItems.Add(oeeItem.TotaleTijdVanSessie.ToString("HH:mm:ss"));
                    lv.SubItems.Add(oeeItem.TotaleTijdActiefVanSessie.ToString("HH:mm:ss"));
                    listViewSavedSessions.Items.Add(lv);
                }
            }
            listViewSavedSessions.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
        }

        #endregion RefreshListView

        #region StatusStrip Update

        private void statusLocalTimeTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (statusStrip.InvokeRequired)
            {
                try
                {
                    statusStrip.Invoke((MethodInvoker)(() => toolStripStatusLabelTime.Text = DateTime.Now.ToString("HH:mm:ss")));
                }
                catch (Exception)
                {
                }
            }
            else
            {
                toolStripStatusLabelTime.Text = DateTime.Now.ToString("HH:mm:ss");
            }
        }

        private void statusRefreshTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (statusStrip.InvokeRequired)
            {
                statusStrip.Invoke(new MethodInvoker(() => UpdateStatus()));
            }
            else
            {
                UpdateStatus();
            }
        }

        private void statusTimeTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            if (statusStrip.InvokeRequired)
            {
                statusStrip.Invoke(new MethodInvoker(() => UpdateTimers()));
            }
            else
            {
                UpdateTimers();
            }
        }

        private void UpdateNoodstopKnop()
        {
            var noodstopInfo = (from info in mijnController.ItemInfoList
                                where info.FilteredName == noodstopOPCNaam
                                select info).FirstOrDefault();
            if (noodstopInfo != null)
            {
                if (mijnController.TimerUitvoer.Enabled == true || Convert.ToBoolean(noodstopInfo.ItemValue) == true)
                    buttonNoodstop.Enabled = true;
                else
                    buttonNoodstop.Enabled = false;

                if (Convert.ToBoolean(noodstopInfo.ItemValue) == true)
                {
                    buttonNoodstop.Text = "Deactiveer Noodstop";
                    buttonNoodstop.BackColor = Color.Green;
                    if (mijnController.TimerUitvoer.Enabled == true)
                        mijnController.TimerUitvoer.Stop();
                }
                else
                {
                    buttonNoodstop.BackColor = Color.Red;
                    buttonNoodstop.Text = "Activeer Noodstop";
                }
            }
        }

        private void UpdatePauzeKnop()
        {
            var pauzeInfo = (from info in mijnController.ItemInfoList
                             where info.FilteredName == pauzeOPCNaam
                             select info).FirstOrDefault();
            if (pauzeInfo != null)
            {
                if (mijnController.TimerUitvoer.Enabled == true || Convert.ToBoolean(pauzeInfo.ItemValue) == true)
                    btnPauze.Enabled = true;
                else
                    btnPauze.Enabled = false;

                if (Convert.ToBoolean(pauzeInfo.ItemValue) == true)
                {
                    btnPauze.Text = "Deactiveer Pauze";
                    btnPauze.BackColor = Color.Red;
                }
                else
                {
                    btnPauze.BackColor = Color.Green;
                    btnPauze.Text = "Activeer Pauze";
                }
            }
        }

        private void UpdateStatus()
        {
            ItemInfo pauze = mijnController.ItemInfoList.Where(infoItem => infoItem.FilteredName == pauzeOPCNaam).FirstOrDefault();
            ItemInfo noodstop = mijnController.ItemInfoList.Where(infoItem => infoItem.FilteredName == noodstopOPCNaam).FirstOrDefault();
            ItemInfo spoelen = mijnController.ItemInfoList.Where(infoItem => infoItem.FilteredName == mengverhouding).FirstOrDefault();
            if (noodstop != null && Convert.ToBoolean(noodstop.ItemValue) == true)
            {
                toolStripStatusLabelNoodstop.Text = "Actief";
                toolStripStatusLabelNoodstop.ForeColor = Color.Red;
            }
            else
            {
                toolStripStatusLabelNoodstop.Text = "Inactief";
                toolStripStatusLabelNoodstop.ForeColor = Color.Green;
            }
            if (pauze != null && Convert.ToBoolean(pauze.ItemValue) == true)
            {
                toolStripStatusLabelPauze.Text = "Actief";
                toolStripStatusLabelPauze.ForeColor = Color.Red;
            }
            else
            {
                toolStripStatusLabelPauze.Text = "Inactief";
                toolStripStatusLabelPauze.ForeColor = Color.Green;
            }
            if (mijnController.CheckVerbinding() == true)
            {
                toolStripStatusLabelVerbinding.Text = "Actief";
                toolStripStatusLabelVerbinding.ForeColor = Color.Green;
            }
            else
            {
                toolStripStatusLabelVerbinding.Text = "Inactief";
                toolStripStatusLabelVerbinding.ForeColor = Color.Red;
            }
            if (spoelen != null && Convert.ToInt32(spoelen.ItemValue) == 0)
            {
                toolStripStatusLabelSpoelen.Text = "Actief";
                toolStripStatusLabelSpoelen.ForeColor = Color.Red;
            }
            else
            {
                toolStripStatusLabelSpoelen.Text = "Inactief";
                toolStripStatusLabelSpoelen.ForeColor = Color.Green;
            }
            if (mijnController.BerekenSchattingResterendeTijd() > 0)
            {
                TimeSpan ts = TimeSpan.FromSeconds(mijnController.BerekenSchattingResterendeTijd() / 1000);
                toolStripStatusLabelResterendeTijd.Text = ts.ToString();
            }
            else
                toolStripStatusLabelResterendeTijd.Text = "0";
            var text = "";
            foreach (var order in mijnController.OrderList)
            {
                if (order.Klaar == false)
                {
                    foreach (var mengbatch in order.MengbatchList)
                    {
                        if (mengbatch.Klaar == false && mengbatch.Status == statusBezig)
                        {
                            text += order.Nummer + "-" + mengbatch.Nummer + ",";
                        }
                    }
                }
            }
            if (text.Length <= 2)
            {
                toolStripStatusLabelMengbatch.Text = "Geen";
                toolStripStatusLabelMengbatch.ForeColor = Color.Red;
            }
            else
            {
                toolStripStatusLabelMengbatch.Text = text;
                toolStripStatusLabelMengbatch.ForeColor = Color.Green;
            }

            if (buttonNoodstop.InvokeRequired)
            {
                buttonNoodstop.Invoke(new MethodInvoker(() => UpdateNoodstopKnop()));
            }
            else
            {
                UpdateNoodstopKnop();
            }

            if (btnPauze.InvokeRequired)
            {
                btnPauze.Invoke(new MethodInvoker(() => UpdatePauzeKnop()));
            }
            else
            {
                UpdatePauzeKnop();
            }
            if (btnUitvoeren.InvokeRequired)
            {
                btnUitvoeren.Invoke(new MethodInvoker(() => UpdateUitvoerKnop()));
            }
            else
            {
                UpdateUitvoerKnop();
            }
        }

        private void UpdateTimers()
        {
            try
            {
                toolStripStatusLabelTimeInActive.Text = Convert.ToDateTime(mijnController.TotalTimeInactive.Elapsed.ToString()).ToString("HH:mm:ss");
                if (toolStripStatusLabelTimeInActive.Text ==
                    Convert.ToDateTime(mijnController.TotalTimeInactive.Elapsed.ToString()).ToString("HH:mm:ss"))
                {
                    toolStripStatusLabelTimeInActive.ForeColor = Color.Red;
                }
                else
                {
                    toolStripStatusLabelTimeInActive.ForeColor = Color.Green;
                }
                toolStripStatusLabelTimeActive.Text = Convert.ToDateTime(mijnController.TotalTimeActive.Elapsed.ToString()).ToString("HH:mm:ss");
                if (toolStripStatusLabelTimeActive.Text == "00:00:00" ||
                    toolStripStatusLabelTimeActive.Text != Convert.ToDateTime(mijnController.TotalTimeActive.Elapsed.ToString()).ToString("HH:mm:ss"))
                {
                    toolStripStatusLabelTimeActive.ForeColor = Color.Red;
                }
                else
                {
                    toolStripStatusLabelTimeActive.ForeColor = Color.Green;
                }
            }
            catch (Exception)
            {
            }
        }

        private void UpdateUitvoerKnop()
        {
            var pauzeInfo = (from info in mijnController.ItemInfoList
                             where info.FilteredName == pauzeOPCNaam
                             select info).FirstOrDefault();
            var noodstopInfo = (from info in mijnController.ItemInfoList
                                where info.FilteredName == noodstopOPCNaam
                                select info).FirstOrDefault();
            if (mijnController.TimerUitvoer.Enabled == true ||
                (pauzeInfo != null && Convert.ToBoolean(pauzeInfo.ItemValue) == true) ||
                (noodstopInfo != null && Convert.ToBoolean(noodstopInfo.ItemValue)) == true ||
                listOrder.Items.Count == 0)
                btnUitvoeren.Enabled = false;
            else
                btnUitvoeren.Enabled = true;
        }

        #endregion StatusStrip Update

        #region OEE

        private void timerRefreshOEE_Elapsed(object sender, ElapsedEventArgs e)
        {
            if (mijnController.CheckVerbinding() == true)
            {
                RefreshListViewOEE();
            }
        }

        #endregion OEE
    }
}